
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Web.Services;
    using HER;
    using AEL.APU;
    using BEL;
    using CEL.APU;
using System;
  namespace EWS
  {
  /// <summary>
  /// Summary description for WS_APU
  /// </summary>
  [WebService(Namespace = "http://koala.org/")]
  [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
  [ToolboxItem(false)]
  public class WS_APU : WebService
  {
   // Posible problema con static y nuevas consultas a la base
   // se debería optimizar la llamada a los objeto DO, 
  // para que esté creado desde el momento de la llamada
   // o
  // que problema existe en concurrencia??
    #region Servicios para Apu_Provincia
    // Objeto permanente para acceso a DO_Apu_Provincia
    private DO_Apu_Provincia _Apu_Provincia ;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Provincia
    /// </summary>
    public DO_Apu_Provincia Apu_Provincia
    {
    get
    {
    if(_Apu_Provincia == null)
    _Apu_Provincia = new DO_Apu_Provincia ();
    return _Apu_Provincia ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Provincia> Apu_Provincia_Get(Scope s)
    {
     return Apu_Provincia.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Provincia
    /// </summary>
    /// <returns>Todos los registros de Apu_Provincia </returns>
    
        [WebMethod]
        public List< Apu_Provincia> Apu_Provincia_GetByCodigo ( Scope s, string codigo)
        {
        return Apu_Provincia.GetByCodigo(s, codigo );
        }
        [WebMethod]
        public List< Apu_Provincia> Apu_Provincia_GetByEmpresa ( Scope s, string int_empresa_id)
        {
        return Apu_Provincia.GetByEmpresa(s, int_empresa_id );
        }
        [WebMethod]
        public List< Apu_Provincia> Apu_Provincia_GetById ( Scope s, string id)
        {
        return Apu_Provincia.GetById(s, id );
        }
        [WebMethod]
        public List< Apu_Provincia> Apu_Provincia_GetByLikeNombre ( Scope s, string letras)
        {
        return Apu_Provincia.GetByLikeNombre(s, letras );
        }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Provincia
    /// <summary>
    /// Borra el objeto de Apu_Provincia
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Provincia_Delete(Scope s, Apu_Provincia o)
    {
    try
    {
    return Apu_Provincia.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Provincia
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Provincia_Insert(Scope s, Apu_Provincia o)
    {
    try
    {
    return Apu_Provincia.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Provincia
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Provincia_Update (Scope s, Apu_Provincia o, Apu_Provincia original)
    {
    try
    {
    return Apu_Provincia.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Categoria
    // Objeto permanente para acceso a DO_Apu_Categoria
    private DO_Apu_Categoria _Apu_Categoria;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Categoria
    /// </summary>
    public DO_Apu_Categoria Apu_Categoria
    {
        get
        {
            if (_Apu_Categoria == null)
                _Apu_Categoria = new DO_Apu_Categoria();
            return _Apu_Categoria;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Categoria> Apu_Categoria_Get(Scope s)
    {
        return Apu_Categoria.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Categoria
    /// </summary>
    /// <returns>Todos los registros de Apu_Categoria </returns>

    [WebMethod]
    public List<Apu_Categoria> Apu_Categoria_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Categoria.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Categoria> Apu_Categoria_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Categoria.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Categoria> Apu_Categoria_GetById(Scope s, string Id)
    {
        return Apu_Categoria.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Categoria> Apu_Categoria_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Categoria.GetByLikeNombre(s, Nombre);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Categoria
    /// <summary>
    /// Borra el objeto de Apu_Categoria
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Categoria_Delete(Scope s, Apu_Categoria o)
    {
        try
        {
            return Apu_Categoria.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Categoria
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Categoria_Insert(Scope s, Apu_Categoria o)
    {
        try
        {
            return Apu_Categoria.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Categoria
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Categoria_Update(Scope s, Apu_Categoria o, Apu_Categoria original)
    {
        try
        {
            return Apu_Categoria.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion
    
    #region Servicios para Apu_Lugar
    // Objeto permanente para acceso a DO_Apu_Lugar
    private DO_Apu_Lugar _Apu_Lugar ;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Lugar
    /// </summary>
    public DO_Apu_Lugar Apu_Lugar
    {
    get
    {
    if(_Apu_Lugar == null)
    _Apu_Lugar = new DO_Apu_Lugar ();
    return _Apu_Lugar ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Lugar> Apu_Lugar_Get(Scope s)
    {
     return Apu_Lugar.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Lugar
    /// </summary>
    /// <returns>Todos los registros de Apu_Lugar </returns>
    
        [WebMethod]
        public List< Apu_Lugar> Apu_Lugar_GetByCodigo ( Scope s, string Codigo)
        {
        return Apu_Lugar.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Apu_Lugar> Apu_Lugar_GetByEmpresa ( Scope s, string int_empresa_id)
        {
        return Apu_Lugar.GetByEmpresa(s, int_empresa_id );
        }
        [WebMethod]
        public List< Apu_Lugar> Apu_Lugar_GetById ( Scope s, string Id)
        {
        return Apu_Lugar.GetById(s, Id );
        }
        [WebMethod]
        public List< Apu_Lugar> Apu_Lugar_GetByLikeNombre ( Scope s, string letras)
        {
        return Apu_Lugar.GetByLikeNombre(s, letras );
        }
        [WebMethod]
        public List< Apu_Lugar> Apu_Lugar_GetByPredeterminada ( Scope s, string apu_provincia_id)
        {
        return Apu_Lugar.GetByPredeterminada(s, apu_provincia_id );
        }
        [WebMethod]
        public List<Apu_Lugar> Apu_Lugar_GetByProvincia(Scope s, string Apu_Provincia_Id)
        {
          return Apu_Lugar.GetByProvincia(s, Apu_Provincia_Id);
        }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Lugar
    /// <summary>
    /// Borra el objeto de Apu_Lugar
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Lugar_Delete(Scope s, Apu_Lugar o)
    {
    try
    {
    return Apu_Lugar.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Lugar
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Lugar_Insert(Scope s, Apu_Lugar o)
    {
    try
    {
        return DEL.APU.DO_Apu_Lugar.Insert(s, o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Lugar
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Lugar_Update (Scope s, Apu_Lugar o, Apu_Lugar original)
    {
    try
    {
    return DEL.APU.DO_Apu_Lugar.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion

    #endregion

    #region Servicios para Apu_Material
    // Objeto permanente para acceso a DO_Apu_Material
    private DO_Apu_Material _Apu_Material;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Material
    /// </summary>
    public DO_Apu_Material Apu_Material
    {
        get
        {
            if (_Apu_Material == null)
                _Apu_Material = new DO_Apu_Material();
            return _Apu_Material;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Material> Apu_Material_Get(Scope s)
    {
        return Apu_Material.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Material
    /// </summary>
    /// <returns>Todos los registros de Apu_Material </returns>

    [WebMethod]
    public List<Apu_Material> Apu_Material_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Material.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Material> Apu_Material_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Material.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Material> Apu_Material_GetById(Scope s, string Id)
    {
        return Apu_Material.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Material> Apu_Material_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Material.GetByLikeNombre(s, Nombre);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Material
    /// <summary>
    /// Borra el objeto de Apu_Material
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Material_Delete(Scope s, Apu_Material o)
    {
        try
        {
            return Apu_Material.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Material
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Material_Insert(Scope s, Apu_Material o)
    {
        try
        {
            return Apu_Material.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Material
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Material_Update(Scope s, Apu_Material o, Apu_Material original)
    {
        try
        {
            return Apu_Material.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
#endregion   
          
    #region Servicios para Apu_Mano_Obra
    // Objeto permanente para acceso a DO_Apu_Mano_Obra
    private DO_Apu_Mano_Obra _Apu_Mano_Obra;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Mano_Obra
    /// </summary>
    public DO_Apu_Mano_Obra Apu_Mano_Obra
    {
        get
        {
            if (_Apu_Mano_Obra == null)
                _Apu_Mano_Obra = new DO_Apu_Mano_Obra();
            return _Apu_Mano_Obra;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Mano_Obra> Apu_Mano_Obra_Get(Scope s)
    {
        return Apu_Mano_Obra.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Mano_Obra
    /// </summary>
    /// <returns>Todos los registros de Apu_Mano_Obra </returns>

    [WebMethod]
    public List<Apu_Mano_Obra> Apu_Mano_Obra_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Mano_Obra.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Mano_Obra> Apu_Mano_Obra_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Mano_Obra.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Mano_Obra> Apu_Mano_Obra_GetById(Scope s, string Id)
    {
        return Apu_Mano_Obra.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Mano_Obra> Apu_Mano_Obra_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Mano_Obra.GetByLikeNombre(s, Nombre);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Mano_Obra
    /// <summary>
    /// Borra el objeto de Apu_Mano_Obra
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Mano_Obra_Delete(Scope s, Apu_Mano_Obra o)
    {
        try
        {
            return Apu_Mano_Obra.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Mano_Obra
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Mano_Obra_Insert(Scope s, Apu_Mano_Obra o)
    {
        try
        {
            return Apu_Mano_Obra.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Mano_Obra
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Mano_Obra_Update(Scope s, Apu_Mano_Obra o, Apu_Mano_Obra original)
    {
        try
        {
            return Apu_Mano_Obra.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Varios
    // Objeto permanente para acceso a DO_Apu_Varios
    private DO_Apu_Varios _Apu_Varios;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Varios
    /// </summary>
    public DO_Apu_Varios Apu_Varios
    {
        get
        {
            if (_Apu_Varios == null)
                _Apu_Varios = new DO_Apu_Varios();
            return _Apu_Varios;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Varios> Apu_Varios_Get(Scope s)
    {
        return Apu_Varios.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Varios
    /// </summary>
    /// <returns>Todos los registros de Apu_Varios </returns>

    [WebMethod]
    public List<Apu_Varios> Apu_Varios_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Varios.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Varios> Apu_Varios_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Varios.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Varios> Apu_Varios_GetById(Scope s, string Id)
    {
        return Apu_Varios.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Varios> Apu_Varios_GetByLikeNombre(Scope s, string Nombre, string Tipo)
    {
        return Apu_Varios.GetByLikeNombre(s, Nombre, Tipo);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Varios
    /// <summary>
    /// Borra el objeto de Apu_Varios
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Varios_Delete(Scope s, Apu_Varios o)
    {
        try
        {
            return Apu_Varios.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Varios
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Varios_Insert(Scope s, Apu_Varios o)
    {
        try
        {
            return Apu_Varios.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Varios
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Varios_Update(Scope s, Apu_Varios o, Apu_Varios original)
    {
        try
        {
            return Apu_Varios.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Estructura
    // Objeto permanente para acceso a DO_Apu_Estructura
    private DO_Apu_Estructura _Apu_Estructura;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Estructura
    /// </summary>
    public DO_Apu_Estructura Apu_Estructura
    {
        get
        {
            if (_Apu_Estructura == null)
                _Apu_Estructura = new DO_Apu_Estructura();
            return _Apu_Estructura;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Estructura> Apu_Estructura_Get(Scope s)
    {
        return Apu_Estructura.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Estructura
    /// </summary>
    /// <returns>Todos los registros de Apu_Estructura </returns>

    [WebMethod]
    public List<Apu_Estructura> Apu_Estructura_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Estructura.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Estructura> Apu_Estructura_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Estructura.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Estructura> Apu_Estructura_GetById(Scope s, string Id)
    {
        return Apu_Estructura.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Estructura> Apu_Estructura_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Estructura.GetByLikeNombre(s, Nombre);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Estructura
    /// <summary>
    /// Borra el objeto de Apu_Estructura
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Estructura_Delete(Scope s, Apu_Estructura o)
    {
        try
        {
            return Apu_Estructura.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Estructura
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Estructura_Insert(Scope s, Apu_Estructura o)
    {
        try
        {
            return Apu_Estructura.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Estructura
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Estructura_Update(Scope s, Apu_Estructura o, Apu_Estructura original)
    {
        try
        {
            return Apu_Estructura.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Estructura_Material
    // Objeto permanente para acceso a DO_Apu_Estructura_Material
    private DO_Apu_Estructura_Material _Apu_Estructura_Material;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Estructura_Material
    /// </summary>
    public DO_Apu_Estructura_Material Apu_Estructura_Material
    {
        get
        {
            if (_Apu_Estructura_Material == null)
                _Apu_Estructura_Material = new DO_Apu_Estructura_Material();
            return _Apu_Estructura_Material;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Estructura_Material> Apu_Estructura_Material_Get(Scope s)
    {
        return Apu_Estructura_Material.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Estructura_Material
    /// </summary>
    /// <returns>Todos los registros de Apu_Estructura_Material </returns>

    [WebMethod]
    public List<Apu_Estructura_Material> Apu_Estructura_Material_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Estructura_Material.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Estructura_Material> Apu_Estructura_Material_GetByEstructura(Scope s, string Apu_Estructura_Id)
    {
        return Apu_Estructura_Material.GetByEstructura(s, Apu_Estructura_Id);
    }
    [WebMethod]
    public List<Apu_Estructura_Material> Apu_Estructura_Material_GetById(Scope s, string Id)
    {
        return Apu_Estructura_Material.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Estructura_Material
    /// <summary>
    /// Borra el objeto de Apu_Estructura_Material
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Estructura_Material_Delete(Scope s, Apu_Estructura_Material o)
    {
        try
        {
            return Apu_Estructura_Material.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Estructura_Material
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Estructura_Material_Insert(Scope s, Apu_Estructura_Material o)
    {
        try
        {
            return Apu_Estructura_Material.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Estructura_Material
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Estructura_Material_Update(Scope s, Apu_Estructura_Material o, Apu_Estructura_Material original)
    {
        try
        {
            return Apu_Estructura_Material.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Estructura_Mano_Obra
    // Objeto permanente para acceso a DO_Apu_Estructura_Mano_Obra
    private DO_Apu_Estructura_Mano_Obra _Apu_Estructura_Mano_Obra;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Estructura_Mano_Obra
    /// </summary>
    public DO_Apu_Estructura_Mano_Obra Apu_Estructura_Mano_Obra
    {
        get
        {
            if (_Apu_Estructura_Mano_Obra == null)
                _Apu_Estructura_Mano_Obra = new DO_Apu_Estructura_Mano_Obra();
            return _Apu_Estructura_Mano_Obra;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Estructura_Mano_Obra> Apu_Estructura_Mano_Obra_Get(Scope s)
    {
        return Apu_Estructura_Mano_Obra.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Estructura_Mano_Obra
    /// </summary>
    /// <returns>Todos los registros de Apu_Estructura_Mano_Obra </returns>

    [WebMethod]
    public List<Apu_Estructura_Mano_Obra> Apu_Estructura_Mano_Obra_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Estructura_Mano_Obra.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Estructura_Mano_Obra> Apu_Estructura_Mano_Obra_GetByEstructura(Scope s, string Apu_Estructura_Id)
    {
        return Apu_Estructura_Mano_Obra.GetByEstructura(s, Apu_Estructura_Id);
    }
    [WebMethod]
    public List<Apu_Estructura_Mano_Obra> Apu_Estructura_Mano_Obra_GetById(Scope s, string Id)
    {
        return Apu_Estructura_Mano_Obra.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Estructura_Mano_Obra
    /// <summary>
    /// Borra el objeto de Apu_Estructura_Mano_Obra
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Estructura_Mano_Obra_Delete(Scope s, Apu_Estructura_Mano_Obra o)
    {
        try
        {
            return Apu_Estructura_Mano_Obra.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Estructura_Mano_Obra
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Estructura_Mano_Obra_Insert(Scope s, Apu_Estructura_Mano_Obra o)
    {
        try
        {
            return Apu_Estructura_Mano_Obra.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Estructura_Mano_Obra
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Estructura_Mano_Obra_Update(Scope s, Apu_Estructura_Mano_Obra o, Apu_Estructura_Mano_Obra original)
    {
        try
        {
            return Apu_Estructura_Mano_Obra.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Estructura_Varios
    // Objeto permanente para acceso a DO_Apu_Estructura_Varios
    private DO_Apu_Estructura_Varios _Apu_Estructura_Varios;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Estructura_Varios
    /// </summary>
    public DO_Apu_Estructura_Varios Apu_Estructura_Varios
    {
        get
        {
            if (_Apu_Estructura_Varios == null)
                _Apu_Estructura_Varios = new DO_Apu_Estructura_Varios();
            return _Apu_Estructura_Varios;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Estructura_Varios> Apu_Estructura_Varios_Get(Scope s)
    {
        return Apu_Estructura_Varios.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Estructura_Varios
    /// </summary>
    /// <returns>Todos los registros de Apu_Estructura_Varios </returns>

    [WebMethod]
    public List<Apu_Estructura_Varios> Apu_Estructura_Varios_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Estructura_Varios.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Estructura_Varios> Apu_Estructura_Varios_GetByEstructura(Scope s, string Apu_Estructura_Id)
    {
        return Apu_Estructura_Varios.GetByEstructura(s, Apu_Estructura_Id);
    }
    [WebMethod]
    public List<Apu_Estructura_Varios> Apu_Estructura_Varios_GetById(Scope s, string Id)
    {
        return Apu_Estructura_Varios.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Estructura_Varios
    /// <summary>
    /// Borra el objeto de Apu_Estructura_Varios
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Estructura_Varios_Delete(Scope s, Apu_Estructura_Varios o)
    {
        try
        {
            return Apu_Estructura_Varios.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Estructura_Varios
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Estructura_Varios_Insert(Scope s, Apu_Estructura_Varios o)
    {
        try
        {
            return Apu_Estructura_Varios.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Estructura_Varios
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Estructura_Varios_Update(Scope s, Apu_Estructura_Varios o, Apu_Estructura_Varios original)
    {
        try
        {
            return Apu_Estructura_Varios.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Tipo_Proyecto
    // Objeto permanente para acceso a DO_Apu_Tipo_Proyecto
    private DO_Apu_Tipo_Proyecto _Apu_Tipo_Proyecto;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Tipo_Proyecto
    /// </summary>
    public DO_Apu_Tipo_Proyecto Apu_Tipo_Proyecto
    {
        get
        {
            if (_Apu_Tipo_Proyecto == null)
                _Apu_Tipo_Proyecto = new DO_Apu_Tipo_Proyecto();
            return _Apu_Tipo_Proyecto;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Tipo_Proyecto> Apu_Tipo_Proyecto_Get(Scope s)
    {
        return Apu_Tipo_Proyecto.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Tipo_Proyecto
    /// </summary>
    /// <returns>Todos los registros de Apu_Tipo_Proyecto </returns>

    [WebMethod]
    public List<Apu_Tipo_Proyecto> Apu_Tipo_Proyecto_GetByCodigo(Scope s, string codigo)
    {
        return Apu_Tipo_Proyecto.GetByCodigo(s, codigo);
    }
    [WebMethod]
    public List<Apu_Tipo_Proyecto> Apu_Tipo_Proyecto_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Tipo_Proyecto.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Tipo_Proyecto> Apu_Tipo_Proyecto_GetById(Scope s, string id)
    {
        return Apu_Tipo_Proyecto.GetById(s, id);
    }
    [WebMethod]
    public List<Apu_Tipo_Proyecto> Apu_Tipo_Proyecto_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Tipo_Proyecto.GetByLikeNombre(s, Nombre);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Tipo_Proyecto
    /// <summary>
    /// Borra el objeto de Apu_Tipo_Proyecto
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Tipo_Proyecto_Delete(Scope s, Apu_Tipo_Proyecto o)
    {
        try
        {
            return Apu_Tipo_Proyecto.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Tipo_Proyecto
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Tipo_Proyecto_Insert(Scope s, Apu_Tipo_Proyecto o)
    {
        try
        {
            return Apu_Tipo_Proyecto.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Tipo_Proyecto
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Tipo_Proyecto_Update(Scope s, Apu_Tipo_Proyecto o, Apu_Tipo_Proyecto original)
    {
        try
        {
            return Apu_Tipo_Proyecto.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Proyecto
    // Objeto permanente para acceso a DO_Apu_Proyecto
    private DO_Apu_Proyecto _Apu_Proyecto;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Proyecto
    /// </summary>
    public DO_Apu_Proyecto Apu_Proyecto
    {
        get
        {
            if (_Apu_Proyecto == null)
                _Apu_Proyecto = new DO_Apu_Proyecto();
            return _Apu_Proyecto;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Proyecto> Apu_Proyecto_Get(Scope s)
    {
        return Apu_Proyecto.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Proyecto
    /// </summary>
    /// <returns>Todos los registros de Apu_Proyecto </returns>

    [WebMethod]
    public List<Apu_Proyecto> Apu_Proyecto_GetByCodigo(Scope s, string codigo)
    {
        return Apu_Proyecto.GetByCodigo(s, codigo);
    }
    [WebMethod]
    public List<Apu_Proyecto> Apu_Proyecto_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Proyecto.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Proyecto> Apu_Proyecto_GetById(Scope s, string id)
    {
        return Apu_Proyecto.GetById(s, id);
    }
    [WebMethod]
    public List<Apu_Proyecto> Apu_Proyecto_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Proyecto.GetByLikeNombre(s, Nombre);
    }
    [WebMethod]
    public List<Apu_Proyecto> Apu_Proyecto_GetByPersonal(Scope s, string Per_Personal_Id)
    {
        return Apu_Proyecto.GetByPersonal(s, Per_Personal_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Proyecto
    /// <summary>
    /// Borra el objeto de Apu_Proyecto
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Proyecto_Delete(Scope s, Apu_Proyecto o)
    {
        try
        {
            return Apu_Proyecto.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Proyecto
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Proyecto_Insert(Scope s, Apu_Proyecto o)
    {
        try
        {
            return Apu_Proyecto.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Proyecto
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Proyecto_Update(Scope s, Apu_Proyecto o, Apu_Proyecto original)
    {
        try
        {
            return Apu_Proyecto.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Orden
    // Objeto permanente para acceso a DO_Apu_Orden
    private DO_Apu_Orden _Apu_Orden;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Orden
    /// </summary>
    public DO_Apu_Orden Apu_Orden
    {
        get
        {
            if (_Apu_Orden == null)
                _Apu_Orden = new DO_Apu_Orden();
            return _Apu_Orden;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Orden> Apu_Orden_Get(Scope s)
    {
        return Apu_Orden.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Orden
    /// </summary>
    /// <returns>Todos los registros de Apu_Orden </returns>

    [WebMethod]
    public List<Apu_Orden> Apu_Orden_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Orden.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Orden> Apu_Orden_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Orden.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
    public List<Apu_Orden> Apu_Orden_GetById(Scope s, string Id)
    {
        return Apu_Orden.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Orden> Apu_Orden_GetByLikeNombre(Scope s, string Nombre)
    {
        return Apu_Orden.GetByLikeNombre(s, Nombre);
    }
    [WebMethod]
    public List<Apu_Orden> Apu_Orden_GetBySucursal(Scope s, string Int_Sucursal_Id)
    {
        return Apu_Orden.GetBySucursal(s, Int_Sucursal_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Orden
    /// <summary>
    /// Borra el objeto de Apu_Orden
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Orden_Delete(Scope s, Apu_Orden o)
    {
        try
        {
            return Apu_Orden.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Orden
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Orden_Insert(Scope s, Apu_Orden o)
    {
        try
        {
            return Apu_Orden.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Orden
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Orden_Update(Scope s, Apu_Orden o, Apu_Orden original)
    {
        try
        {
            return Apu_Orden.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Pedido
    // Objeto permanente para acceso a DO_Apu_Pedido
    private DO_Apu_Pedido _Apu_Pedido;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Pedido
    /// </summary>
    public DO_Apu_Pedido Apu_Pedido
    {
        get
        {
            if (_Apu_Pedido == null)
                _Apu_Pedido = new DO_Apu_Pedido();
            return _Apu_Pedido;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_Get(Scope s)
    {
        return Apu_Pedido.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Pedido
    /// </summary>
    /// <returns>Todos los registros de Apu_Pedido </returns>

    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetByBodega(Scope s, string Bod_Bodega_Id)
    {
        return Apu_Pedido.GetByBodega(s, Bod_Bodega_Id);
    }
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Pedido.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetByEmpresa(Scope s, string Int_Empresa_Id)
    {
        return Apu_Pedido.GetByEmpresa(s, Int_Empresa_Id);
    }
    [WebMethod]
      public List<Apu_Pedido> Apu_Pedido_GetByEstado(Scope s, string Estado, DateTime Fecha, string Bod_Bodega_Id)
    {
        return Apu_Pedido.GetByEstado(s,Estado,Fecha, Bod_Bodega_Id);
    }
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetByFecha(Scope s, DateTime Fecha)
    {
        return Apu_Pedido.GetByFecha(s, Fecha);
    }
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetById(Scope s, string Id)
    {
        return Apu_Pedido.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetByOrden(Scope s, string Apu_Orden_Id)
    {
        return Apu_Pedido.GetByOrden(s, Apu_Orden_Id);
    }
    [WebMethod]
    public List<Apu_Pedido> Apu_Pedido_GetBySucursal(Scope s, string Int_Sucursal_Id)
    {
        return Apu_Pedido.GetBySucursal(s, Int_Sucursal_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Pedido
    /// <summary>
    /// Borra el objeto de Apu_Pedido
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Pedido_Delete(Scope s, Apu_Pedido o)
    {
        try
        {
            return Apu_Pedido.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Pedido
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Pedido_Insert(Scope s, Apu_Pedido o)
    {
        try
        {
            return Apu_Pedido.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Pedido
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Pedido_Update(Scope s, Apu_Pedido o, Apu_Pedido original)
    {
        try
        {
            return Apu_Pedido.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Pedido_Estructura
    // Objeto permanente para acceso a DO_Apu_Pedido_Estructura
    private DO_Apu_Pedido_Estructura _Apu_Pedido_Estructura;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Pedido_Estructura
    /// </summary>
    public DO_Apu_Pedido_Estructura Apu_Pedido_Estructura
    {
        get
        {
            if (_Apu_Pedido_Estructura == null)
                _Apu_Pedido_Estructura = new DO_Apu_Pedido_Estructura();
            return _Apu_Pedido_Estructura;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Pedido_Estructura> Apu_Pedido_Estructura_Get(Scope s)
    {
        return Apu_Pedido_Estructura.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Pedido_Estructura
    /// </summary>
    /// <returns>Todos los registros de Apu_Pedido_Estructura </returns>

    [WebMethod]
    public List<Apu_Pedido_Estructura> Apu_Pedido_Estructura_GetByCantidad(Scope s, decimal Cantidad)
    {
        return Apu_Pedido_Estructura.GetByCantidad(s, Cantidad);
    }
    [WebMethod]
    public List<Apu_Pedido_Estructura> Apu_Pedido_Estructura_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Pedido_Estructura.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Pedido_Estructura> Apu_Pedido_Estructura_GetByFechaCreacion(Scope s, DateTime Fecha)
    {
        return Apu_Pedido_Estructura.GetByFechaCreacion(s, Fecha);
    }
    [WebMethod]
    public List<Apu_Pedido_Estructura> Apu_Pedido_Estructura_GetById(Scope s, string Id)
    {
        return Apu_Pedido_Estructura.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Pedido_Estructura> Apu_Pedido_Estructura_GetByPedido(Scope s, string Apu_Pedido_Id)
    {
        return Apu_Pedido_Estructura.GetByPedido(s, Apu_Pedido_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Pedido_Estructura
    /// <summary>
    /// Borra el objeto de Apu_Pedido_Estructura
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Pedido_Estructura_Delete(Scope s, Apu_Pedido_Estructura o)
    {
        try
        {
            return Apu_Pedido_Estructura.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Pedido_Estructura
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
      public string Apu_Pedido_Estructura_Insert(Scope s, Apu_Pedido_Estructura oApu_Pedido_Estructura)
    {
        try
        {
            return DEL.APU.DO_Apu_Pedido_Estructura.Insert(s,oApu_Pedido_Estructura);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Pedido_Estructura
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Pedido_Estructura_Update(Scope s, Apu_Pedido_Estructura o, Apu_Pedido_Estructura original)
    {
        try
        {
            return Apu_Pedido_Estructura.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Apu_Pedido_Estructura_Det
    // Objeto permanente para acceso a DO_Apu_Pedido_Estructura_Det
    private DO_Apu_Pedido_Estructura_Det _Apu_Pedido_Estructura_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Apu_Pedido_Estructura_Det
    /// </summary>
    public DO_Apu_Pedido_Estructura_Det Apu_Pedido_Estructura_Det
    {
        get
        {
            if (_Apu_Pedido_Estructura_Det == null)
                _Apu_Pedido_Estructura_Det = new DO_Apu_Pedido_Estructura_Det();
            return _Apu_Pedido_Estructura_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Apu_Pedido_Estructura_Det> Apu_Pedido_Estructura_Det_Get(Scope s)
    {
        return Apu_Pedido_Estructura_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Apu_Pedido_Estructura_Det
    /// </summary>
    /// <returns>Todos los registros de Apu_Pedido_Estructura_Det </returns>

    [WebMethod]
    public List<Apu_Pedido_Estructura_Det> Apu_Pedido_Estructura_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Apu_Pedido_Estructura_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Apu_Pedido_Estructura_Det> Apu_Pedido_Estructura_Det_GetById(Scope s, string Id)
    {
        return Apu_Pedido_Estructura_Det.GetById(s, Id);
    }
    [WebMethod]
    public List<Apu_Pedido_Estructura_Det> Apu_Pedido_Estructura_Det_GetByPedidoEstructura(Scope s, string Apu_Pedido_Estructura_Id)
    {
        return Apu_Pedido_Estructura_Det.GetByPedidoEstructura(s, Apu_Pedido_Estructura_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Apu_Pedido_Estructura_Det
    /// <summary>
    /// Borra el objeto de Apu_Pedido_Estructura_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Apu_Pedido_Estructura_Det_Delete(Scope s, Apu_Pedido_Estructura_Det o)
    {
        try
        {
            return Apu_Pedido_Estructura_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Apu_Pedido_Estructura_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Apu_Pedido_Estructura_Det_Insert(Scope s, Apu_Pedido_Estructura_Det o)
    {
        try
        {
            return Apu_Pedido_Estructura_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Apu_Pedido_Estructura_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Apu_Pedido_Estructura_Det_Update(Scope s, Apu_Pedido_Estructura_Det o, Apu_Pedido_Estructura_Det original)
    {
        try
        {
            return Apu_Pedido_Estructura_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    }
  }
  
